package com.example.testapp.config

import android.content.Context
import android.util.Log
import com.example.testapp.config.model.AppConfig
import com.google.gson.Gson
import com.google.gson.GsonBuilder
import java.io.BufferedReader
import java.io.BufferedWriter
import java.io.File
import java.io.FileReader
import java.io.FileWriter
import java.io.IOException

/**
 * 配置管理类，负责读取和保存应用配置
 * 使用单例模式确保全局唯一实例
 */
class ConfigManager private constructor(context: Context) {
    private val context: Context = context.applicationContext
    private val gson: Gson = GsonBuilder().setPrettyPrinting().create()
    private var config: AppConfig = AppConfig.getDefaultConfig()

    init {
        loadConfig()
    }

    /**
     * 获取当前配置
     * @return 应用配置对象
     */
    fun getConfig(): AppConfig {
        return config
    }

    /**
     * 保存配置到外部存储
     * @return 是否保存成功
     */
    fun saveConfig(): Boolean {
        val configFile = getConfigFile()
        return try {
            BufferedWriter(FileWriter(configFile)).use { writer ->
                val jsonConfig = gson.toJson(config)
                writer.write(jsonConfig)
                true
            }
        } catch (e: IOException) {
            Log.e(TAG, "保存配置失败: ${e.message}", e)
            false
        }
    }

    /**
     * 更新配置并保存
     * @param newConfig 新的配置对象
     * @return 是否保存成功
     */
    fun updateConfig(newConfig: AppConfig): Boolean {
        this.config = newConfig
        return saveConfig()
    }

    /**
     * 重置为默认配置
     * @return 是否重置成功
     */
    fun resetToDefault(): Boolean {
        this.config = AppConfig.getDefaultConfig()
        return saveConfig()
    }

    /**
     * 从外部存储加载配置
     */
    private fun loadConfig() {
        val configFile = getConfigFile()

        // 如果配置文件不存在，创建默认配置
        if (!configFile.exists()) {
            config = AppConfig.getDefaultConfig()
            saveConfig()
            return
        }

        try {
            BufferedReader(FileReader(configFile)).use { reader ->
                val jsonBuilder = StringBuilder()
                var line: String?
                while (reader.readLine().also { line = it } != null) {
                    jsonBuilder.append(line)
                }

                val json = jsonBuilder.toString()
                val loadedConfig = gson.fromJson(json, AppConfig::class.java)

                // 如果解析出来的config是null，使用默认配置
                config = loadedConfig ?: AppConfig.getDefaultConfig()
            }
        } catch (e: IOException) {
            Log.e(TAG, "加载配置失败: ${e.message}", e)
            config = AppConfig.getDefaultConfig()
            saveConfig()
        }
    }

    /**
     * 获取配置文件对象
     * @return 配置文件
     */
    private fun getConfigFile(): File {
        // 获取应用专用的外部存储目录
        val externalFilesDir = context.getExternalFilesDir(null)

        // 创建config子目录
        val configDir = File(externalFilesDir, "config")
        if (!configDir.exists()) {
            val created = configDir.mkdirs()
            if (!created) {
                Log.e(TAG, "创建配置目录失败")
            }
        }

        // 返回配置文件
        return File(configDir, CONFIG_FILE_NAME)
    }

    companion object {
        private const val TAG = "ConfigManager"
        private const val CONFIG_FILE_NAME = "app_config.json"

        @Volatile
        private var instance: ConfigManager? = null

        /**
         * 获取ConfigManager的单例实例
         * @param context 应用上下文
         * @return ConfigManager实例
         */
        @JvmStatic
        fun getInstance(context: Context): ConfigManager {
            return instance ?: synchronized(this) {
                instance ?: ConfigManager(context).also { instance = it }
            }
        }
    }
} 